import type { CAC } from 'cac';
import type { Result } from 'publint';

import { basename, dirname, join } from 'node:path';

import { colors, consola, ensureFile, findMonorepoRoot, generatorContentHash, getPackages, outputJSON, readJSON, UNICODE } from '@croco/node-utils';

import { publint } from 'publint';
import { formatMessage } from 'publint/utils';

const CACHE_FILE = join('node_modules', '.cache', 'publint', '.pkglintcache.json');

interface PubLintCommandOptions {
    /**
     * Only errors are checked, no program exit is performed
     */
    check?: boolean;
}

/**
 * Get files that require lint
 * @param files
 */
async function getLintFiles(files: string[] = []) {
    const lintFiles: string[] = [];

    if (files?.length > 0) {
        return files.filter((file) => basename(file) === 'package.json');
    }

    const { packages } = await getPackages();

    for (const { dir } of packages) {
        lintFiles.push(join(dir, 'package.json'));
    }
    return lintFiles;
}

function getCacheFile() {
    const root = findMonorepoRoot();
    return join(root, CACHE_FILE);
}

async function readCache(cacheFile: string) {
    try {
        await ensureFile(cacheFile);
        return await readJSON(cacheFile);
    } catch {
        return {};
    }
}

async function runPublint(files: string[], { check }: PubLintCommandOptions) {
    const lintFiles = await getLintFiles(files);
    const cacheFile = getCacheFile();

    const cacheData = await readCache(cacheFile);
    const cache: Record<string, { hash: string; result: Result }> = cacheData;

    const results = await Promise.all(
        lintFiles.map(async (file) => {
            try {
                const pkgJson = await readJSON(file);

                if (pkgJson.private) {
                    return null;
                }

                Reflect.deleteProperty(pkgJson, 'dependencies');
                Reflect.deleteProperty(pkgJson, 'devDependencies');
                Reflect.deleteProperty(pkgJson, 'peerDependencies');
                const content = JSON.stringify(pkgJson);
                const hash = generatorContentHash(content);

                const publintResult: Result =
                    cache?.[file]?.hash === hash
                        ? (cache?.[file]?.result ?? [])
                        : await publint({
                              level: 'suggestion',
                              pkgDir: dirname(file),
                              strict: true,
                          });

                cache[file] = {
                    hash,
                    result: publintResult,
                };

                return { pkgJson, pkgPath: file, publintResult };
            } catch {
                return null;
            }
        }),
    );

    await outputJSON(cacheFile, cache);
    printResult(results, check);
}

function printResult(
    results: Array<null | {
        pkgJson: Record<string, number | string>;
        pkgPath: string;
        publintResult: Result;
    }>,
    check?: boolean,
) {
    let errorCount = 0;
    let warningCount = 0;
    let suggestionsCount = 0;

    for (const result of results) {
        if (!result) {
            continue;
        }
        const { pkgJson, pkgPath, publintResult } = result;
        const messages = publintResult?.messages ?? [];
        if (messages?.length < 1) {
            continue;
        }

        consola.log('');
        consola.log(pkgPath);
        for (const message of messages) {
            switch (message.type) {
                case 'error': {
                    errorCount++;

                    break;
                }
                case 'suggestion': {
                    suggestionsCount++;
                    break;
                }
                case 'warning': {
                    warningCount++;

                    break;
                }
                // No default
            }
            const ruleUrl = `https://publint.dev/rules#${message.code.toLocaleLowerCase()}`;
            consola.log(`  ${formatMessage(message, pkgJson)}${colors.dim(` ${ruleUrl}`)}`);
        }
    }

    const totalCount = warningCount + errorCount + suggestionsCount;
    if (totalCount > 0) {
        consola.error(colors.red(`${UNICODE.FAILURE} ${totalCount} problem (${errorCount} errors, ${warningCount} warnings, ${suggestionsCount} suggestions)`));
        !check && process.exit(1);
    } else {
        consola.log(colors.green(`${UNICODE.SUCCESS} No problem`));
    }
}

function definePubLintCommand(cac: CAC) {
    cac.command('publint [...files]')
        .usage('Check if the monorepo package conforms to the publint standard.')
        .option('--check', 'Only errors are checked, no program exit is performed.')
        .action(runPublint);
}

export { definePubLintCommand };
